home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / win / vb / inpgrid.exe / CURSOR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-21  |  46.1 KB  |  1,328 lines
  1. //---------------------------------------------------------------------------
  2. // Cursor.c
  3. //---------------------------------------------------------------------------
  4. // Griglia Control
  5. //---------------------------------------------------------------------------
  6.  
  7. #define NOCOMM
  8.  
  9. #include <windows.h>
  10.  
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <ctype.h>
  14. #include "vbapi.h"
  15. #include "griglia.h"
  16.  
  17. static BOOL         PaintCursorLocal                 (PGRIGLIA, HDC);
  18. static SHORT NEAR    ReturnIncrement                    (PGRIGLIA, WORD);
  19. BOOL LBlockButtonDown (PGRIGLIA, POINT);
  20.  
  21. //---------------------------------------------------------------------------
  22. // ResetRow
  23. //---------------------------------------------------------------------------
  24. BOOL ResetRow (PGRIGLIA lpGrigliaStruct,
  25.                WORD     wRow) {
  26.  
  27.     RECT  rStatic;    
  28.     BOOL  bRet = FALSE;    
  29.  
  30.     GetClientRect (lpGrigliaStruct->hWndStatic,     (LPRECT)&rStatic);    
  31.  
  32.     // Reset Scroll to view current line    
  33.     if (lpGrigliaStruct->wTopRow > wRow) {    
  34.         Griglia_VScroll (lpGrigliaStruct,        
  35.                           SB_THUMBTRACK,                         
  36.                           MAKELONG (wRow                                            -                     
  37.                                     lpGrigliaStruct->wTopRow    +                               
  38.                                     lpGrigliaStruct->nVScrollPos,0)                               
  39.                                    );            
  40.         bRet = TRUE;        
  41.     } else {    
  42.  
  43.         LONG  lScroll;    
  44.         SHORT nGap;    
  45.  
  46.         lScroll = Griglia_VertPos (wRow, lpGrigliaStruct);        
  47.         nGap    = LOWORD (PUSH_V_GRID + lScroll) - (WORD)rStatic.bottom;        
  48.         if ((lScroll != INVALID_POS) && (nGap > 0)) {        
  49.             Griglia_VScroll (lpGrigliaStruct,            
  50.                              SB_THUMBTRACK,                            
  51.                              MAKELONG (wRow                                            -                            
  52.                                        lpGrigliaStruct->wTopRow    +                                      
  53.                                        lpGrigliaStruct->nVScrollPos, 0));                                    
  54.             bRet = TRUE;            
  55.         }        
  56.     }    
  57.     return (bRet);    
  58. }
  59.  
  60. //---------------------------------------------------------------------------
  61. // ResetCol
  62. //---------------------------------------------------------------------------
  63. BOOL ResetCol (PGRIGLIA lpGrigliaStruct,
  64.                WORD     wCol) {
  65.  
  66.     RECT  rStatic;
  67.     BOOL  bRet = FALSE;
  68.  
  69.     GetClientRect (lpGrigliaStruct->hWndStatic, (LPRECT)&rStatic);
  70.  
  71.     // Reset Scroll to view current column
  72.     if (lpGrigliaStruct->wLeftCol > wCol) {
  73.         Griglia_HScroll (lpGrigliaStruct,
  74.                          SB_THUMBTRACK,
  75.                          MAKELONG (wCol                         -
  76.                                    lpGrigliaStruct->wLeftCol    +
  77.                                    lpGrigliaStruct->nHScrollPos, 0)
  78.                                    );
  79.         bRet = TRUE;
  80.     } else {
  81.  
  82.         LONG  lScroll;
  83.         SHORT nGap;
  84.  
  85.         lScroll = Griglia_HorPos (wCol, lpGrigliaStruct);
  86.         nGap    = LOWORD (PUSH_H_GRID + lScroll) - (WORD)rStatic.right;
  87.         if ((lScroll != INVALID_POS) && (nGap > 0)) {
  88.             Griglia_HScroll (lpGrigliaStruct,
  89.                             SB_THUMBTRACK,
  90.                             MAKELONG (wCol                        -
  91.                                       lpGrigliaStruct->wLeftCol   +
  92.                                       lpGrigliaStruct->nHScrollPos, 0));
  93.             bRet = TRUE;
  94.         }
  95.     }
  96.  
  97.     return (bRet);
  98. }
  99.  
  100. //---------------------------------------------------------------------------
  101. // ReturnIncrement
  102. //---------------------------------------------------------------------------
  103. static SHORT NEAR ReturnIncrement ( PGRIGLIA lpGrigliaStruct,
  104.                                     WORD     wDirection) {
  105.  
  106.     RECT  rStatic;
  107.     SHORT nGap;
  108.     LONG  lScroll;
  109.  
  110.     GetClientRect (lpGrigliaStruct->hWndStatic,
  111.                                (LPRECT)&rStatic);
  112.  
  113.     switch (wDirection) {
  114.  
  115.         case VK_DOWN:
  116.             // Get Next Cell Position
  117.             lScroll = Griglia_VertPos (lpGrigliaStruct->wCursorRow + 1,
  118.                                        lpGrigliaStruct);
  119.             nGap    = LOWORD (PUSH_V_GRID + lScroll) - (WORD)rStatic.bottom;
  120.  
  121.             // If it exceeds grid compute incr
  122.             if (
  123.                 (lScroll != INVALID_POS) &&
  124.                 (nGap > 0)
  125.                ) {
  126.                 int     n;
  127.                 WORD    wSize = 0;
  128.  
  129.                 for (n = lpGrigliaStruct->wTopRow;
  130.                      n < (SHORT)lpGrigliaStruct->wRows;
  131.                      ++n) {
  132.  
  133.                     wSize += ((lpGrigliaStruct->lpHorBars + n)->wSize +
  134.                               lpGrigliaStruct->yChar / INTERCOLUMN_FACTOR);
  135.                     if ((SHORT)wSize >= nGap)
  136.                         return (n + 1 - lpGrigliaStruct->wTopRow);
  137.                 }
  138.             }
  139.             break;
  140.  
  141.         case VK_RIGHT:
  142.             // Get Next Cell Position
  143.             lScroll = Griglia_HorPos (lpGrigliaStruct->wCursorCol + 1,
  144.                                       lpGrigliaStruct);
  145.             if (lScroll == INVALID_POS)
  146.                 break;
  147.  
  148.             nGap = LOWORD (PUSH_H_GRID + lScroll) - (WORD) rStatic.right;
  149.             // If it exceeds grid compute incr
  150.             if (nGap > 0) {
  151.  
  152.                 int     n;
  153.                 LONG    lSize;
  154.  
  155.                 for (n = lpGrigliaStruct->wLeftCol + 1;
  156.                      n < (SHORT)lpGrigliaStruct->wCols;
  157.                      ++n) {
  158.  
  159.                     lSize = (lpGrigliaStruct->lpVertBars + n)->lPos -
  160.                             (lpGrigliaStruct->lpVertBars +
  161.                              lpGrigliaStruct->wLeftCol)->lPos;
  162.                     if (LOWORD (lSize) >= (WORD)nGap)
  163.                         return (n - lpGrigliaStruct->wLeftCol);
  164.                 }
  165.             }
  166.             break;
  167.     }
  168.  
  169.     return (NULL);
  170. }
  171.  
  172. //---------------------------------------------------------------------------
  173. // MoveCursorLeft
  174. //---------------------------------------------------------------------------
  175. BOOL MoveCursorLeft (PGRIGLIA lpGrigliaStruct) {
  176.  
  177.     if (bShiftPressed) {
  178.  
  179.         // Remove Selection
  180.         PaintBlock (lpGrigliaStruct);
  181.  
  182.         // Set Selection to Cursor
  183.         if (bCtrlPressed)
  184.             lpGrigliaStruct->wSelEndCol = max (lpGrigliaStruct->wSelStartCol,
  185.                                                 lpGrigliaStruct->wSelEndCol - 1);
  186.         else
  187.             lpGrigliaStruct->wSelStartCol = max (lpGrigliaStruct->wFixedCols,
  188.                                                   lpGrigliaStruct->wSelStartCol - 1);
  189.  
  190.         // Remove Selection
  191.         PaintBlock (lpGrigliaStruct);
  192.         return (TRUE);
  193.  
  194.     } else {
  195.  
  196.         if (lpGrigliaStruct->wCursorCol > lpGrigliaStruct->wFixedCols) {
  197.  
  198.             // Reset Scroll to view current col
  199.             ResetRow (lpGrigliaStruct,
  200.                           lpGrigliaStruct->wCursorRow);
  201.  
  202.             if (!ResetCol (lpGrigliaStruct,
  203.                                  lpGrigliaStruct->wCursorCol - 1)) {
  204.  
  205.                 if (lpGrigliaStruct->wCursorCol <=
  206.                     (lpGrigliaStruct->wFixedCols +
  207.                      lpGrigliaStruct->nHScrollPos))
  208.                     Griglia_HScroll (lpGrigliaStruct, SB_LINEUP, (LONG)NULL);
  209.  
  210.             }
  211.  
  212.             // Remove Selection
  213.             PaintBlock (lpGrigliaStruct);
  214.  
  215.             PaintCursor (lpGrigliaStruct);
  216.             --lpGrigliaStruct->wCursorCol;
  217.             lpGrigliaStruct->wCol = lpGrigliaStruct->wCursorCol;
  218.             PaintCursor (lpGrigliaStruct);
  219.             SetEditText (lpGrigliaStruct,
  220.                          lpGrigliaStruct->wCursorRow,
  221.                          lpGrigliaStruct->wCursorCol);
  222.  
  223.             // Set Selection to Cursor
  224.             lpGrigliaStruct->wSelStartRow =
  225.                         lpGrigliaStruct->wCursorRow;
  226.             lpGrigliaStruct->wSelEndRow =
  227.                         lpGrigliaStruct->wCursorRow;
  228.             lpGrigliaStruct->wSelStartCol =
  229.                         lpGrigliaStruct->wCursorCol;
  230.             lpGrigliaStruct->wSelEndCol =
  231.                         lpGrigliaStruct->wCursorCol;
  232.  
  233.         }
  234.         return (TRUE);
  235.     }
  236.     return (FALSE);
  237. }
  238.  
  239. //---------------------------------------------------------------------------
  240. // MoveCursorRight
  241. //---------------------------------------------------------------------------
  242. BOOL MoveCursorRight (PGRIGLIA lpGrigliaStruct) {
  243.  
  244.     if (bShiftPressed) {
  245.  
  246.         // Remove Selection
  247.         PaintBlock (lpGrigliaStruct);
  248.  
  249.         // Set Selection to Cursor
  250.         if (bCtrlPressed)
  251.             lpGrigliaStruct->wSelStartCol = min (lpGrigliaStruct->wSelEndCol,
  252.                                                  lpGrigliaStruct->wSelStartCol + 1);
  253.         else {
  254.             lpGrigliaStruct->wSelEndCol = min (lpGrigliaStruct->wCols - 1,
  255.                                                lpGrigliaStruct->wSelEndCol + 1);
  256.         }
  257.         // Remove Selection
  258.         PaintBlock (lpGrigliaStruct);
  259.         return (TRUE);
  260.  
  261.     } else {
  262.  
  263.         if (lpGrigliaStruct->wCursorCol < (lpGrigliaStruct->wCols - 1)) {
  264.             SHORT nIncr;
  265.  
  266.             // Reset Scroll to view current col
  267.             ResetRow (lpGrigliaStruct,
  268.                       lpGrigliaStruct->wCursorRow);
  269.  
  270.             // Scroll if necessary
  271.             if (nIncr = ReturnIncrement (lpGrigliaStruct, VK_RIGHT))
  272.                 Griglia_HScroll (lpGrigliaStruct,
  273.                                  SB_THUMBTRACK,
  274.                                  MAKELONG (nIncr +
  275.                                            lpGrigliaStruct->nHScrollPos, 0));
  276.             ResetCol (lpGrigliaStruct,
  277.                       lpGrigliaStruct->wCursorCol);
  278.  
  279.             // Remove Selection
  280.             PaintBlock (lpGrigliaStruct);
  281.  
  282.             PaintCursor (lpGrigliaStruct);
  283.             ++lpGrigliaStruct->wCursorCol;
  284.             lpGrigliaStruct->wCol = lpGrigliaStruct->wCursorCol;
  285.             PaintCursor (lpGrigliaStruct);
  286.             SetEditText (lpGrigliaStruct,
  287.                          lpGrigliaStruct->wCursorRow,
  288.                          lpGrigliaStruct->wCursorCol);
  289.  
  290.             // Set Selection to Cursor
  291.             lpGrigliaStruct->wSelStartRow =
  292.                             lpGrigliaStruct->wCursorRow;
  293.             lpGrigliaStruct->wSelEndRow =
  294.                             lpGrigliaStruct->wCursorRow;
  295.             lpGrigliaStruct->wSelStartCol =
  296.                             lpGrigliaStruct->wCursorCol;
  297.             lpGrigliaStruct->wSelEndCol =
  298.                             lpGrigliaStruct->wCursorCol;
  299.  
  300.             return (TRUE);
  301.         }
  302.     }
  303.     return (FALSE);
  304.  
  305. }
  306.  
  307. //---------------------------------------------------------------------------
  308. // MoveCursorUp
  309. //---------------------------------------------------------------------------
  310. BOOL MoveCursorUp (PGRIGLIA lpGrigliaStruct) {
  311.  
  312.     if (bShiftPressed) {
  313.  
  314.         // Remove Selection
  315.         PaintBlock (lpGrigliaStruct);
  316.  
  317.         // Set Selection to Cursor
  318.         if (bCtrlPressed)
  319.             lpGrigliaStruct->wSelEndRow = max (lpGrigliaStruct->wSelStartRow,
  320.                                                   lpGrigliaStruct->wSelEndRow - 1);
  321.         else
  322.             lpGrigliaStruct->wSelStartRow = max (lpGrigliaStruct->wFixedRows,
  323.                                                  lpGrigliaStruct->wSelStartRow - 1);
  324.  
  325.         // Remove Selection
  326.         PaintBlock (lpGrigliaStruct);
  327.         return (TRUE);
  328.  
  329.     } else {
  330.  
  331.         if (lpGrigliaStruct->wCursorRow > lpGrigliaStruct->wFixedRows) {
  332.  
  333.             // Reset Scroll to view current line
  334.             ResetCol (lpGrigliaStruct,
  335.                           lpGrigliaStruct->wCursorCol);
  336.  
  337.             if (!ResetRow (lpGrigliaStruct,
  338.                            lpGrigliaStruct->wCursorRow - 1)) {
  339.  
  340.                 // See if further scroll is necessary
  341.                 if (lpGrigliaStruct->wCursorRow <=
  342.                     (lpGrigliaStruct->wFixedRows +
  343.                      lpGrigliaStruct->nVScrollPos))
  344.                     Griglia_VScroll (lpGrigliaStruct, SB_LINEUP, (LONG)NULL);
  345.             }
  346.  
  347.             // Remove Selection
  348.             PaintBlock (lpGrigliaStruct);
  349.  
  350.             PaintCursor (lpGrigliaStruct);
  351.             --lpGrigliaStruct->wCursorRow;
  352.             lpGrigliaStruct->wRow = lpGrigliaStruct->wCursorRow;
  353.             PaintCursor (lpGrigliaStruct);
  354.             SetEditText (lpGrigliaStruct,
  355.                          lpGrigliaStruct->wCursorRow,
  356.                          lpGrigliaStruct->wCursorCol);
  357.  
  358.             // Set Selection to Cursor
  359.             lpGrigliaStruct->wSelStartRow =
  360.                         lpGrigliaStruct->wCursorRow;
  361.             lpGrigliaStruct->wSelEndRow =
  362.                         lpGrigliaStruct->wCursorRow;
  363.             lpGrigliaStruct->wSelStartCol =
  364.                         lpGrigliaStruct->wCursorCol;
  365.             lpGrigliaStruct->wSelEndCol =
  366.                         lpGrigliaStruct->wCursorCol;
  367.  
  368.             return (TRUE);
  369.         }
  370.     }
  371.     return (FALSE);
  372. }
  373.  
  374. //---------------------------------------------------------------------------
  375. // MoveCursorDown
  376. //---------------------------------------------------------------------------
  377. BOOL MoveCursorDown (PGRIGLIA lpGrigliaStruct) {
  378.  
  379.  
  380.     if (bShiftPressed) {
  381.  
  382.         // Remove Selection
  383.         PaintBlock (lpGrigliaStruct);
  384.  
  385.         // Set Selection to Cursor
  386.         if (bCtrlPressed)
  387.                 lpGrigliaStruct->wSelStartRow = min (lpGrigliaStruct->wSelEndRow,
  388.                                                                                    lpGrigliaStruct->wSelStartRow + 1);
  389.         else
  390.                 lpGrigliaStruct->wSelEndRow = min (lpGrigliaStruct->wRows - 1,
  391.                                                                                    lpGrigliaStruct->wSelEndRow + 1);
  392.  
  393.         // Remove Selection
  394.         PaintBlock (lpGrigliaStruct);
  395.         return (TRUE);
  396.  
  397.     } else {
  398.  
  399.         // See if further scroll is necessary
  400.         if (lpGrigliaStruct->wCursorRow < (lpGrigliaStruct->wRows - 1)) {
  401.                 SHORT nIncr;
  402.  
  403.             // Reset Scroll to view current line
  404.             ResetCol (lpGrigliaStruct,
  405.                       lpGrigliaStruct->wCursorCol);
  406.             // Scroll if necessary
  407.             if (nIncr = ReturnIncrement (lpGrigliaStruct, VK_DOWN))
  408.                 Griglia_VScroll (lpGrigliaStruct,
  409.                                 SB_THUMBTRACK,
  410.                                 MAKELONG (nIncr +
  411.                                           lpGrigliaStruct->nVScrollPos, 0));
  412.             ResetRow (lpGrigliaStruct,
  413.                       lpGrigliaStruct->wCursorRow);
  414.  
  415.             // Remove Selection
  416.             PaintBlock (lpGrigliaStruct);
  417.  
  418.             PaintCursor (lpGrigliaStruct);
  419.             ++lpGrigliaStruct->wCursorRow;
  420.             lpGrigliaStruct->wRow = lpGrigliaStruct->wCursorRow;
  421.             PaintCursor (lpGrigliaStruct);
  422.             SetEditText (lpGrigliaStruct,
  423.                                     lpGrigliaStruct->wCursorRow,
  424.                                     lpGrigliaStruct->wCursorCol);
  425.  
  426.             // Set Selection to Cursor
  427.             lpGrigliaStruct->wSelStartRow =
  428.                                     lpGrigliaStruct->wCursorRow;
  429.             lpGrigliaStruct->wSelEndRow =
  430.                                     lpGrigliaStruct->wCursorRow;
  431.             lpGrigliaStruct->wSelStartCol =
  432.                                     lpGrigliaStruct->wCursorCol;
  433.             lpGrigliaStruct->wSelEndCol =
  434.                                     lpGrigliaStruct->wCursorCol;
  435.  
  436.             return (TRUE);
  437.         }
  438.     }
  439.     return (FALSE);
  440.  
  441. }
  442.  
  443. //---------------------------------------------------------------------------
  444. // MoveCursorHome
  445. //---------------------------------------------------------------------------
  446. BOOL MoveCursorHome (PGRIGLIA lpGrigliaStruct,
  447.                      BOOL     bCtrlPressed) {
  448.  
  449.     if (bShiftPressed) {
  450.  
  451.         // Remove Selection
  452.         PaintBlock (lpGrigliaStruct);
  453.  
  454.         // Set Selection to Cursor
  455.         if (bCtrlPressed) {
  456.             lpGrigliaStruct->wSelStartRow =
  457.                         lpGrigliaStruct->wFixedRows;
  458.             lpGrigliaStruct->wSelEndRow =
  459.                         lpGrigliaStruct->wCursorRow;
  460.         } else {
  461.             lpGrigliaStruct->wSelStartRow =
  462.                         lpGrigliaStruct->wCursorRow;
  463.             lpGrigliaStruct->wSelEndRow =
  464.                         lpGrigliaStruct->wCursorRow;
  465.         }
  466.         lpGrigliaStruct->wSelStartCol =
  467.                     lpGrigliaStruct->wFixedCols;
  468.         lpGrigliaStruct->wSelEndCol =
  469.                     lpGrigliaStruct->wCursorCol;
  470.  
  471.         // Remove Selection
  472.         PaintBlock (lpGrigliaStruct);
  473.  
  474.     } else {
  475.  
  476.         // Scroll if necessary
  477.         Griglia_HScroll (lpGrigliaStruct, SB_TOP, (LONG)NULL);
  478.         if (bCtrlPressed)
  479.                 Griglia_VScroll (lpGrigliaStruct, SB_TOP, (LONG)NULL);
  480.  
  481.         // Remove Selection
  482.         PaintBlock (lpGrigliaStruct);
  483.  
  484.         PaintCursor (lpGrigliaStruct);
  485.         if (bCtrlPressed) {
  486.             lpGrigliaStruct->wCursorRow = lpGrigliaStruct->wFixedRows;
  487.             lpGrigliaStruct->wRow       = lpGrigliaStruct->wCursorRow;
  488.         }
  489.         lpGrigliaStruct->wCursorCol = lpGrigliaStruct->wFixedCols;
  490.         lpGrigliaStruct->wCol       = lpGrigliaStruct->wCursorCol;
  491.         PaintCursor (lpGrigliaStruct);
  492.         SetEditText (lpGrigliaStruct,
  493.                      lpGrigliaStruct->wCursorRow,
  494.                      lpGrigliaStruct->wCursorCol);
  495.  
  496.         // Set Selection to Cursor
  497.         lpGrigliaStruct->wSelStartRow =
  498.                     lpGrigliaStruct->wCursorRow;
  499.         lpGrigliaStruct->wSelEndRow =
  500.                     lpGrigliaStruct->wCursorRow;
  501.         lpGrigliaStruct->wSelStartCol =
  502.                     lpGrigliaStruct->wCursorCol;
  503.         lpGrigliaStruct->wSelEndCol =
  504.                     lpGrigliaStruct->wCursorCol;
  505.     }
  506.     return (TRUE);
  507.  
  508. }
  509.  
  510. //---------------------------------------------------------------------------
  511. // MoveCursorEnd
  512. //---------------------------------------------------------------------------
  513. BOOL MoveCursorEnd (PGRIGLIA lpGrigliaStruct,
  514.                     BOOL     bCtrlPressed) {
  515.  
  516.     if (bShiftPressed) {
  517.  
  518.         // Remove Selection
  519.         PaintBlock (lpGrigliaStruct);
  520.  
  521.         // Set Selection to Cursor
  522.         if (bCtrlPressed) {
  523.             lpGrigliaStruct->wSelStartRow =
  524.                         lpGrigliaStruct->wCursorRow;
  525.             lpGrigliaStruct->wSelEndRow =
  526.                         lpGrigliaStruct->wRows - 1;
  527.         } else {
  528.             lpGrigliaStruct->wSelStartRow =
  529.                         lpGrigliaStruct->wCursorRow;
  530.             lpGrigliaStruct->wSelEndRow =
  531.                         lpGrigliaStruct->wCursorRow;
  532.         }
  533.         lpGrigliaStruct->wSelStartCol =
  534.                     lpGrigliaStruct->wCursorCol;
  535.         lpGrigliaStruct->wSelEndCol =
  536.                     lpGrigliaStruct->wCols - 1;
  537.  
  538.         // Remove Selection
  539.         PaintBlock (lpGrigliaStruct);
  540.  
  541.     } else {
  542.  
  543.         // Scroll if necessary
  544.         Griglia_HScroll (lpGrigliaStruct, SB_BOTTOM, (LONG)NULL);
  545.  
  546.         if (bCtrlPressed)
  547.             Griglia_VScroll (lpGrigliaStruct, SB_BOTTOM, (LONG)NULL);
  548.  
  549.         // Remove Selection
  550.         PaintBlock (lpGrigliaStruct);
  551.  
  552.         PaintCursor (lpGrigliaStruct);
  553.         if (bCtrlPressed) {
  554.             lpGrigliaStruct->wCursorRow = lpGrigliaStruct->wRows - 1;
  555.             lpGrigliaStruct->wRow       = lpGrigliaStruct->wCursorRow;
  556.         }
  557.         lpGrigliaStruct->wCursorCol = lpGrigliaStruct->wCols - 1;
  558.         lpGrigliaStruct->wCol       = lpGrigliaStruct->wCursorCol;
  559.         PaintCursor (lpGrigliaStruct);
  560.         SetEditText (lpGrigliaStruct,
  561.                      lpGrigliaStruct->wCursorRow,
  562.                      lpGrigliaStruct->wCursorCol);
  563.  
  564.         // Set Selection to Cursor
  565.         lpGrigliaStruct->wSelStartRow =
  566.                     lpGrigliaStruct->wCursorRow;
  567.         lpGrigliaStruct->wSelEndRow =
  568.                     lpGrigliaStruct->wCursorRow;
  569.         lpGrigliaStruct->wSelStartCol =
  570.                     lpGrigliaStruct->wCursorCol;
  571.         lpGrigliaStruct->wSelEndCol =
  572.                     lpGrigliaStruct->wCursorCol;
  573.         return (TRUE);
  574.     }
  575. }
  576.  
  577. //---------------------------------------------------------------------------
  578. // MoveCursorPrior
  579. //---------------------------------------------------------------------------
  580. BOOL MoveCursorPrior (PGRIGLIA lpGrigliaStruct,
  581.                       BOOL     bCtrlPressed) {
  582.  
  583.     if (bShiftPressed) {
  584.  
  585.         // Remove Selection
  586.         PaintBlock (lpGrigliaStruct);
  587.  
  588.         // Set Selection to Cursor
  589.         if (bCtrlPressed) {
  590.             lpGrigliaStruct->wSelStartRow =
  591.                         lpGrigliaStruct->wFixedRows;
  592.             lpGrigliaStruct->wSelEndRow =
  593.                         lpGrigliaStruct->wCursorRow;
  594.         } else {
  595.             int nPos,
  596.                 nIncr,
  597.                 newPos;
  598.  
  599.             nPos  = (lpGrigliaStruct->wCursorRow - lpGrigliaStruct->wFixedRows);
  600.  
  601.             // Compute increment to align on page border
  602.             nIncr = nPos % lpGrigliaStruct->nVScrollInc;
  603.             if ((nPos) && (!nIncr))
  604.                 nIncr = lpGrigliaStruct->nVScrollInc;
  605.  
  606.             newPos = max (lpGrigliaStruct->wFixedRows,
  607.                           lpGrigliaStruct->wCursorRow - nIncr);
  608.  
  609.             lpGrigliaStruct->wSelStartRow = newPos;
  610.             lpGrigliaStruct->wSelEndRow =
  611.                         lpGrigliaStruct->wCursorRow;
  612.         }
  613.         lpGrigliaStruct->wSelStartCol =
  614.                     lpGrigliaStruct->wCursorCol;
  615.         lpGrigliaStruct->wSelEndCol =
  616.                     lpGrigliaStruct->wCursorCol;
  617.  
  618.         // Remove Selection
  619.         PaintBlock (lpGrigliaStruct);
  620.  
  621.     } else {
  622.  
  623.         // Remove Selection
  624.         PaintBlock (lpGrigliaStruct);
  625.  
  626.         if (bCtrlPressed) {
  627.  
  628.             Griglia_VScroll (lpGrigliaStruct, SB_TOP, (LONG)NULL);
  629.             PaintCursor (lpGrigliaStruct);
  630.             lpGrigliaStruct->wCursorRow = lpGrigliaStruct->wFixedRows;
  631.             lpGrigliaStruct->wRow         = lpGrigliaStruct->wCursorRow;
  632.             PaintCursor (lpGrigliaStruct);
  633.  
  634.         } else {
  635.             int nPos,
  636.                 nIncr,
  637.                 newPos;
  638.  
  639.             // Distance from fixed rows
  640.             nPos  = (lpGrigliaStruct->wCursorRow - lpGrigliaStruct->wFixedRows);
  641.  
  642.             // Compute increment to align on page border
  643.             nIncr = nPos % lpGrigliaStruct->nVScrollInc;
  644.             if ((nPos) && (!nIncr))
  645.                 nIncr = lpGrigliaStruct->nVScrollInc;
  646.  
  647.             newPos = max (lpGrigliaStruct->wFixedRows,
  648.                           lpGrigliaStruct->wCursorRow - nIncr);
  649.             if (newPos < (SHORT)lpGrigliaStruct->wTopRow)
  650.                 Griglia_VScroll (lpGrigliaStruct,
  651.                                  SB_THUMBTRACK,
  652.                                  MAKELONG (lpGrigliaStruct->nVScrollPos -
  653.                                             nIncr, 0));
  654.  
  655.             PaintCursor (lpGrigliaStruct);
  656.             lpGrigliaStruct->wCursorRow = newPos;
  657.             lpGrigliaStruct->wRow         = lpGrigliaStruct->wCursorRow;
  658.             PaintCursor (lpGrigliaStruct);
  659.         }
  660.         SetEditText (lpGrigliaStruct,
  661.                      lpGrigliaStruct->wCursorRow,
  662.                      lpGrigliaStruct->wCursorCol);
  663.  
  664.         // Set Selection to Cursor
  665.         lpGrigliaStruct->wSelStartRow =
  666.                     lpGrigliaStruct->wCursorRow;
  667.         lpGrigliaStruct->wSelEndRow =
  668.                     lpGrigliaStruct->wCursorRow;
  669.         lpGrigliaStruct->wSelStartCol =
  670.                     lpGrigliaStruct->wCursorCol;
  671.         lpGrigliaStruct->wSelEndCol =
  672.                     lpGrigliaStruct->wCursorCol;
  673.     }
  674.     return (TRUE);
  675.  
  676. }
  677.  
  678. //---------------------------------------------------------------------------
  679. // MoveCursorNext
  680. //---------------------------------------------------------------------------
  681. BOOL MoveCursorNext (PGRIGLIA lpGrigliaStruct,
  682.                      BOOL     bCtrlPressed) {
  683.  
  684.     if (bShiftPressed) {
  685.  
  686.         // Remove Selection
  687.         PaintBlock (lpGrigliaStruct);
  688.  
  689.         // Set Selection to Cursor
  690.         if (bCtrlPressed) {
  691.             lpGrigliaStruct->wSelStartRow =
  692.                         lpGrigliaStruct->wCursorRow;
  693.             lpGrigliaStruct->wSelEndRow =
  694.                         lpGrigliaStruct->wRows - 1;
  695.         } else {
  696.             int nPos,
  697.                 nIncr,
  698.                 newPos;
  699.  
  700.             // Distance from fixed rows
  701.             nPos  = (lpGrigliaStruct->wCursorRow + 1        -
  702.                      lpGrigliaStruct->wFixedRows);
  703.  
  704.             // Compute increment to align on page border
  705.             nIncr = lpGrigliaStruct->nVScrollInc -
  706.                     nPos % lpGrigliaStruct->nVScrollInc;
  707.             if ((nPos) && (!nIncr))
  708.                 nIncr = lpGrigliaStruct->nVScrollInc;
  709.  
  710.             newPos = min (lpGrigliaStruct->wRows - 1,
  711.                           lpGrigliaStruct->wCursorRow + nIncr);
  712.  
  713.             lpGrigliaStruct->wSelStartRow =
  714.                         lpGrigliaStruct->wCursorRow;
  715.             lpGrigliaStruct->wSelEndRow = newPos;
  716.         }
  717.         lpGrigliaStruct->wSelStartCol =
  718.                     lpGrigliaStruct->wCursorCol;
  719.         lpGrigliaStruct->wSelEndCol =
  720.                     lpGrigliaStruct->wCursorCol;
  721.  
  722.         // Remove Selection
  723.         PaintBlock (lpGrigliaStruct);
  724.  
  725.     } else {
  726.  
  727.         // Remove Selection
  728.         PaintBlock (lpGrigliaStruct);
  729.  
  730.         if (bCtrlPressed) {
  731.  
  732.             Griglia_VScroll (lpGrigliaStruct, SB_BOTTOM, (LONG)NULL);
  733.             PaintCursor (lpGrigliaStruct);
  734.             lpGrigliaStruct->wCursorRow = lpGrigliaStruct->wRows - 1;
  735.             lpGrigliaStruct->wRow         = lpGrigliaStruct->wCursorRow;
  736.             PaintCursor (lpGrigliaStruct);
  737.  
  738.         } else {
  739.  
  740.             int nPos,
  741.                 nIncr,
  742.                 newPos;
  743.  
  744.             // Distance from fixed rows
  745.             nPos  = (lpGrigliaStruct->wCursorRow + 1        -
  746.                      lpGrigliaStruct->wFixedRows);
  747.  
  748.             // Compute increment to align on page border
  749.             nIncr = lpGrigliaStruct->nVScrollInc -
  750.                     nPos % lpGrigliaStruct->nVScrollInc;
  751.             if ((nPos) && (!nIncr))
  752.                 nIncr = lpGrigliaStruct->nVScrollInc;
  753.  
  754.             newPos = min (lpGrigliaStruct->wRows - 1,
  755.                           lpGrigliaStruct->wCursorRow + nIncr);
  756.             Griglia_VScroll (lpGrigliaStruct,
  757.                              SB_THUMBTRACK,
  758.                              MAKELONG (lpGrigliaStruct->nVScrollPos +
  759.                                         nIncr, 0));
  760.  
  761.             PaintCursor (lpGrigliaStruct);
  762.             lpGrigliaStruct->wCursorRow = newPos;
  763.             lpGrigliaStruct->wRow         = lpGrigliaStruct->wCursorRow;
  764.             PaintCursor (lpGrigliaStruct);
  765.  
  766.         }
  767.         SetEditText (lpGrigliaStruct,
  768.                      lpGrigliaStruct->wCursorRow,
  769.                      lpGrigliaStruct->wCursorCol);
  770.  
  771.         // Set Selection to Cursor
  772.         lpGrigliaStruct->wSelStartRow =
  773.                     lpGrigliaStruct->wCursorRow;
  774.         lpGrigliaStruct->wSelEndRow =
  775.                     lpGrigliaStruct->wCursorRow;
  776.         lpGrigliaStruct->wSelStartCol =
  777.                     lpGrigliaStruct->wCursorCol;
  778.         lpGrigliaStruct->wSelEndCol =
  779.                     lpGrigliaStruct->wCursorCol;
  780.     }
  781.     return (TRUE);
  782. }
  783.  
  784. //---------------------------------------------------------------------------
  785. // LButtonDown
  786. //---------------------------------------------------------------------------
  787. void LButtonDown (PGRIGLIA lpGrigliaStruct,
  788.                   POINT    pPoint) {
  789.  
  790.     static POINT pOut;
  791.     static RECT  rRect;
  792.            UINT  nCol, nRow;
  793.  
  794.     // Block Selection ?
  795.     if (LBlockButtonDown (lpGrigliaStruct, pPoint))
  796.         return;
  797.  
  798.     if (FindCell (lpGrigliaStruct,
  799.                   (LPPOINT)&pOut,
  800.                   pPoint)) {    
  801.                         
  802.         nCol = pOut.x;
  803.         nRow = pOut.y;
  804.         
  805.         // Remove Selection    
  806.         PaintBlock (lpGrigliaStruct);    
  807.         if (    
  808.             (nCol != lpGrigliaStruct->wCursorCol) ||    
  809.             (nRow != lpGrigliaStruct->wCursorRow)    
  810.             ) {   
  811.             PaintCursor (lpGrigliaStruct);        
  812.             lpGrigliaStruct->wCursorCol = nCol;
  813.             lpGrigliaStruct->wCursorRow = nRow;
  814.             lpGrigliaStruct->wCol       = nCol;        
  815.             lpGrigliaStruct->wRow       = nRow;        
  816.             PaintCursor (lpGrigliaStruct);        
  817.         }    
  818.         SetEditText (lpGrigliaStruct,    
  819.                     lpGrigliaStruct->wCursorRow,                 
  820.                     lpGrigliaStruct->wCursorCol);                 
  821.         
  822.         // Set Selection to Cursor    
  823.         lpGrigliaStruct->wSelStartRow =    
  824.                         lpGrigliaStruct->wCursorRow;        
  825.         lpGrigliaStruct->wSelEndRow =    
  826.                         lpGrigliaStruct->wCursorRow;        
  827.         lpGrigliaStruct->wSelStartCol =    
  828.                         lpGrigliaStruct->wCursorCol;        
  829.         lpGrigliaStruct->wSelEndCol =    
  830.                         lpGrigliaStruct->wCursorCol;        
  831.         return;    
  832.     }   
  833. }
  834.  
  835.  
  836. //---------------------------------------------------------------------------
  837. // Paint Block
  838. //---------------------------------------------------------------------------
  839. BOOL PaintBlockLocal (PGRIGLIA lpGrigliaStruct,
  840.                       HDC      hDC) {                  
  841.  
  842.     RECT  rCursor, rBlock;
  843.     HRGN  hBlockRgn  = 0, 
  844.           hCursorRgn = 0;    
  845.  
  846.     // If single cell,  skip    
  847.     if (    
  848.         (lpGrigliaStruct->wSelStartCol == lpGrigliaStruct->wSelEndCol) &&        
  849.         (lpGrigliaStruct->wSelStartRow == lpGrigliaStruct->wSelEndRow)        
  850.        )   
  851.         return (TRUE);   
  852.     
  853.     if (BlockRect ( lpGrigliaStruct,    
  854.                     lpGrigliaStruct->wSelStartCol,   
  855.                     lpGrigliaStruct->wSelEndCol,   
  856.                     lpGrigliaStruct->wSelStartRow,   
  857.                     lpGrigliaStruct->wSelEndRow,   
  858.                     (LPRECT)&rBlock)) {   
  859.  
  860.         // paint block                
  861.         ++rBlock.bottom;                        
  862.         ++rBlock.right;                        
  863.  
  864.         hBlockRgn  = CreateRectRgn (rBlock.left,                                
  865.                                     rBlock.top,                                                        
  866.                                     rBlock.right,                                                            
  867.                                     rBlock.bottom);                                                                
  868.  
  869.         if (hBlockRgn) {            
  870.             if (CellRect (lpGrigliaStruct,        
  871.                           lpGrigliaStruct->wCursorCol,          
  872.                           lpGrigliaStruct->wCursorRow,          
  873.                           (LPRECT)&rCursor)) {          
  874.                                     
  875.                 hCursorRgn = CreateRectRgn (rCursor.left,                                
  876.                                             rCursor.top,                                                                    
  877.                                             rCursor.right,                                                            
  878.                                             rCursor.bottom);                                                    
  879.                 if (hCursorRgn) {        
  880.                     CombineRgn (hBlockRgn, hBlockRgn, hCursorRgn,                
  881.                                 RGN_DIFF);                
  882.                     DeleteObject (hCursorRgn);                                
  883.                 }        
  884.             }        
  885.             InvertRgn (hDC, hBlockRgn);                
  886.             DeleteObject (hBlockRgn);                                    
  887.             return (TRUE);                            
  888.         }                        
  889.     }    
  890.     return (FALSE);    
  891.  
  892. }
  893.  
  894. //---------------------------------------------------------------------------
  895. // Paint Block
  896. //---------------------------------------------------------------------------
  897. BOOL PaintBlock (PGRIGLIA lpGrigliaStruct) {
  898.  
  899.     HDC   hDC;        
  900.     BOOL  bRet;    
  901.  
  902.     // Get DC of Static Window
  903.     if (    
  904.         (lpGrigliaStruct->hWndStatic) &&        
  905.         (hDC = GetDC (lpGrigliaStruct->hWndStatic))        
  906.        ){       
  907.  
  908.         bRet = PaintBlockLocal (lpGrigliaStruct, hDC);        
  909.         ReleaseDC (lpGrigliaStruct->hWndStatic, hDC);        
  910.         return (bRet);        
  911.  
  912.     }    
  913.     return (FALSE);    
  914.  
  915. }
  916.  
  917. //---------------------------------------------------------------------------
  918. // LBlockButtonDown
  919. //---------------------------------------------------------------------------
  920. BOOL LBlockButtonDown (PGRIGLIA lpGrigliaStruct,
  921.                        POINT    pPoint) {       
  922.  
  923.            SHORT n, m;
  924.            RECT  rStatic;  
  925.     static RECT  rRect, rNewButton;
  926.  
  927.     GetClientRect (lpGrigliaStruct->hWndStatic,     (LPRECT)&rStatic);
  928.  
  929.     // Handle Vertical or Horizontal Block Selection
  930.     if (
  931.         (pPoint.x < PUSH_H_GRID) &&
  932.         (pPoint.y < PUSH_V_GRID)
  933.        ) {
  934.         HDC hDC;
  935.  
  936.         if (        
  937.             (lpGrigliaStruct->wSelStartRow != lpGrigliaStruct->wFixedRows) ||        
  938.             (lpGrigliaStruct->wSelEndRow   != lpGrigliaStruct->wRows - 1)  ||    
  939.             (lpGrigliaStruct->wSelStartCol != lpGrigliaStruct->wFixedCols) ||    
  940.             (lpGrigliaStruct->wSelEndCol   != lpGrigliaStruct->wCols - 1)    
  941.            ) {   
  942.  
  943.             PaintBlock (lpGrigliaStruct);
  944.  
  945.             // Paint and Move Cursor to Top Left Pos        
  946.             if (        
  947.                 (lpGrigliaStruct->wFixedCols !=            
  948.                         lpGrigliaStruct->wCursorCol) ||             
  949.                 (lpGrigliaStruct->wFixedRows !=            
  950.                         lpGrigliaStruct->wCursorRow)     
  951.                ) {       
  952.                 PaintCursor (lpGrigliaStruct);                
  953.                 lpGrigliaStruct->wCursorCol = lpGrigliaStruct->wFixedCols;            
  954.                 lpGrigliaStruct->wCursorRow = lpGrigliaStruct->wFixedRows;            
  955.                 lpGrigliaStruct->wCol       = lpGrigliaStruct->wFixedCols;            
  956.                 lpGrigliaStruct->wRow       = lpGrigliaStruct->wFixedRows;            
  957.                 PaintCursor (lpGrigliaStruct);            
  958.             }        
  959.  
  960.             SetEditText (lpGrigliaStruct,        
  961.                          lpGrigliaStruct->wCursorRow,                     
  962.                          lpGrigliaStruct->wCursorCol);                     
  963.  
  964.             lpGrigliaStruct->wSelStartRow = lpGrigliaStruct->wFixedRows;        
  965.             lpGrigliaStruct->wSelEndRow   = lpGrigliaStruct->wRows - 1;        
  966.             lpGrigliaStruct->wSelStartCol = lpGrigliaStruct->wFixedCols;        
  967.             lpGrigliaStruct->wSelEndCol   = lpGrigliaStruct->wCols - 1;        
  968.             PaintBlock (lpGrigliaStruct);
  969.  
  970.         }
  971.  
  972.         rNewButton.left   = 1;
  973.         rNewButton.top    = 1;
  974.         rNewButton.right  = PUSH_H_GRID - 1;
  975.         rNewButton.bottom = PUSH_V_GRID - 1;
  976.         if (!EqualRect ((LPRECT)&rButton,
  977.                         (LPRECT)&rNewButton)) {    
  978.                     
  979.             // Raise previous button if still down
  980.             if (!IsRectEmpty ((LPRECT)&rButton))
  981.                 LButtonUp (lpGrigliaStruct, pPoint);
  982.             hDC = GetDC (lpGrigliaStruct->hWndStatic);
  983.             PaintButtonDown (hDC,
  984.                             rNewButton.left,
  985.                             rNewButton.top,
  986.                             rNewButton.right,
  987.                             rNewButton.bottom);
  988.             ReleaseDC (lpGrigliaStruct->hWndStatic, hDC);
  989.             rButton = rNewButton;               
  990.         
  991.         }    
  992.         
  993.         return (TRUE);    
  994.  
  995.     } else if (pPoint.x < PUSH_H_GRID) {
  996.  
  997.         // Scan Rows    
  998.         for (m = (lpGrigliaStruct->wFixedRows +
  999.                   lpGrigliaStruct->nVScrollPos);      
  1000.              m < (SHORT)lpGrigliaStruct->wRows; 
  1001.              ++m) {    
  1002.         
  1003.             if (
  1004.                 (CellTBRect (lpGrigliaStruct, m, (LPRECT)&rRect)) &&
  1005.                 (rRect.top    <= pPoint.y)                        &&                                  
  1006.                 (rRect.bottom >= pPoint.y) 
  1007.                ) {
  1008.  
  1009.                 if (                
  1010.                     ((SHORT)lpGrigliaStruct->wSelStartRow != m)  ||                
  1011.                     ((SHORT)lpGrigliaStruct->wSelEndRow   != m)  ||                
  1012.                     (lpGrigliaStruct->wSelStartCol != lpGrigliaStruct->wFixedCols) ||                
  1013.                     (lpGrigliaStruct->wSelEndCol   != lpGrigliaStruct->wCols - 1)                
  1014.                    ) {               
  1015.  
  1016.                     PaintBlock (lpGrigliaStruct);            
  1017.  
  1018.                     // Paint and Move Cursor to Top Left Pos                    
  1019.                     if (                    
  1020.                         (lpGrigliaStruct->wFixedCols !=                    
  1021.                             lpGrigliaStruct->wCursorCol) ||                     
  1022.                         (m != (SHORT)lpGrigliaStruct->wCursorRow)                                                 
  1023.                        ) {                        
  1024.                         PaintCursor (lpGrigliaStruct);
  1025.                         lpGrigliaStruct->wCursorCol = lpGrigliaStruct->wFixedCols;
  1026.                         lpGrigliaStruct->wCursorRow = m;
  1027.                         lpGrigliaStruct->wCol       = lpGrigliaStruct->wFixedCols;
  1028.                         lpGrigliaStruct->wRow       = m;
  1029.                         PaintCursor (lpGrigliaStruct);
  1030.                     }                    
  1031.  
  1032.                     SetEditText (lpGrigliaStruct,                    
  1033.                                 lpGrigliaStruct->wCursorRow,                                
  1034.                                 lpGrigliaStruct->wCursorCol);                                
  1035.  
  1036.                     lpGrigliaStruct->wSelStartRow = m;                    
  1037.                     lpGrigliaStruct->wSelEndRow   = m;                    
  1038.                     lpGrigliaStruct->wSelStartCol = lpGrigliaStruct->wFixedCols;                    
  1039.                     lpGrigliaStruct->wSelEndCol   = lpGrigliaStruct->wCols - 1;                    
  1040.                     PaintBlock (lpGrigliaStruct);            
  1041.  
  1042.                 }
  1043.  
  1044.                 // PRESS BUTTON
  1045.                 {
  1046.                     HDC hDC;
  1047.  
  1048.                     rNewButton.left   = 1;
  1049.                     rNewButton.top    = rRect.top + 1;
  1050.                     rNewButton.right  = PUSH_H_GRID - 1;
  1051.                     rNewButton.bottom = rRect.bottom;
  1052.                     if (!EqualRect ((LPRECT)&rButton,
  1053.                                     (LPRECT)&rNewButton)) {    
  1054.                     
  1055.                         // Raise previous button if still down
  1056.                         if (!IsRectEmpty ((LPRECT)&rButton))
  1057.                             LButtonUp (lpGrigliaStruct, pPoint);
  1058.  
  1059.                         hDC = GetDC (lpGrigliaStruct->hWndStatic);
  1060.                         PaintButtonDown (hDC,
  1061.                                          rNewButton.left,
  1062.                                          rNewButton.top,
  1063.                                          rNewButton.right,
  1064.                                          rNewButton.bottom);
  1065.                         ReleaseDC (lpGrigliaStruct->hWndStatic, hDC);
  1066.                         rButton = rNewButton;
  1067.                     }
  1068.                 }
  1069.                 return (TRUE);
  1070.             }    
  1071.         }    
  1072.  
  1073.     } else if (pPoint.y < PUSH_V_GRID) {
  1074.  
  1075.         // Scan Columns
  1076.         for (n = (lpGrigliaStruct->wFixedCols + lpGrigliaStruct->nHScrollPos);
  1077.              n < (SHORT)lpGrigliaStruct->wCols; ++n) {
  1078.  
  1079.             if (
  1080.                 (CellLRRect (lpGrigliaStruct, n, (LPRECT)&rRect)) &&
  1081.                 (rRect.left   <= pPoint.x)                        &&                                  
  1082.                 (rRect.right  >= pPoint.x) 
  1083.                ) {
  1084.                 if (                    
  1085.                     ((SHORT)lpGrigliaStruct->wSelStartCol != n)  ||                        
  1086.                     ((SHORT)lpGrigliaStruct->wSelEndCol   != n)  ||                        
  1087.                     (lpGrigliaStruct->wSelStartRow != lpGrigliaStruct->wFixedRows) ||                        
  1088.                     (lpGrigliaStruct->wSelEndRow   != lpGrigliaStruct->wRows - 1)                        
  1089.                 ) {                   
  1090.  
  1091.                     PaintBlock (lpGrigliaStruct);                
  1092.  
  1093.                     // Paint and Move Cursor to Top Left Pos                        
  1094.                     if (                        
  1095.                         (n != (SHORT)lpGrigliaStruct->wCursorCol) ||                        
  1096.                         (lpGrigliaStruct->wFixedCols !=                            
  1097.                         lpGrigliaStruct->wCursorRow)                             
  1098.                        ) {                            
  1099.                         PaintCursor (lpGrigliaStruct);
  1100.                         lpGrigliaStruct->wCursorCol = n;
  1101.                         lpGrigliaStruct->wCursorRow = lpGrigliaStruct->wFixedRows;
  1102.                         lpGrigliaStruct->wCol           = n;
  1103.                         lpGrigliaStruct->wRow           = lpGrigliaStruct->wFixedRows;
  1104.                         PaintCursor (lpGrigliaStruct);
  1105.                     }                        
  1106.  
  1107.                     SetEditText (lpGrigliaStruct,                        
  1108.                                 lpGrigliaStruct->wCursorRow,                                    
  1109.                                 lpGrigliaStruct->wCursorCol);                                    
  1110.  
  1111.                     lpGrigliaStruct->wSelStartCol = n;
  1112.                     lpGrigliaStruct->wSelEndCol   = n;
  1113.                     lpGrigliaStruct->wSelStartRow = lpGrigliaStruct->wFixedRows;
  1114.                     lpGrigliaStruct->wSelEndRow   = lpGrigliaStruct->wRows - 1;
  1115.                     PaintBlock (lpGrigliaStruct);
  1116.  
  1117.                 }   
  1118.                      
  1119.                 // PRESS BUTTON    
  1120.                 {    
  1121.                     HDC hDC;
  1122.  
  1123.                     rNewButton.left   = rRect.left +
  1124.                                         lpGrigliaStruct->xChar / (2 * INTERCOLUMN_FACTOR);
  1125.                     rNewButton.top    = 1;
  1126.                     rNewButton.right  = rRect.right + 1;
  1127.                     rNewButton.bottom = PUSH_V_GRID - 1;
  1128.                     if (!EqualRect ((LPRECT)&rButton,
  1129.                                     (LPRECT)&rNewButton)) {    
  1130.                     
  1131.                         // Raise previous button if still down
  1132.                         if (!IsRectEmpty ((LPRECT)&rButton))
  1133.                             LButtonUp (lpGrigliaStruct, pPoint);
  1134.  
  1135.                         hDC = GetDC (lpGrigliaStruct->hWndStatic);
  1136.                         PaintButtonDown (hDC,
  1137.                                          rNewButton.left,
  1138.                                          rNewButton.top,
  1139.                                          rNewButton.right,
  1140.                                          rNewButton.bottom);
  1141.                         ReleaseDC (lpGrigliaStruct->hWndStatic, hDC);
  1142.                         rButton = rNewButton;
  1143.                     }
  1144.                 }    
  1145.                 return (TRUE);                
  1146.                 
  1147.             }        
  1148.         }        
  1149.     }
  1150.     return (FALSE);
  1151. }
  1152.  
  1153. //---------------------------------------------------------------------------
  1154. // LMouseMoveDown
  1155. //---------------------------------------------------------------------------
  1156. void LMouseMoveDown (PGRIGLIA lpGrigliaStruct,
  1157.                      POINT      pPoint) {
  1158.  
  1159.     LONG  lLeft, lRight, lTop, lBottom, lHScroll, lVScroll;
  1160.     SHORT n, m;
  1161.     RECT  rStatic;
  1162.     WORD  wCol, wRow;
  1163.  
  1164.     GetClientRect (lpGrigliaStruct->hWndStatic,    (LPRECT)&rStatic);
  1165.  
  1166.     lLeft = PUSH_H_GRID;
  1167.     if (lpGrigliaStruct->wFixedCols)
  1168.         lLeft = (lpGrigliaStruct->lpVertBars  +
  1169.                  lpGrigliaStruct->wFixedCols - 1)->lPos;
  1170.  
  1171.     // Scan Other Columns
  1172.     for (n = (lpGrigliaStruct->wFixedCols + lpGrigliaStruct->nHScrollPos);
  1173.          n < (SHORT)lpGrigliaStruct->wCols; ++n) {
  1174.  
  1175.         if ((lHScroll =
  1176.                  Griglia_HorPos (n, lpGrigliaStruct)) !=
  1177.              INVALID_POS) {
  1178.             lRight = PUSH_H_GRID + lHScroll -
  1179.                       lpGrigliaStruct->xChar / (2 * INTERCOLUMN_FACTOR);
  1180.  
  1181.             if (lLeft > (LONG)rStatic.right)
  1182.                 return;
  1183.             else if (
  1184.                       (lLeft  <= pPoint.x) &&
  1185.                       (lRight >= pPoint.x)
  1186.                     ) {
  1187.                 wCol = n;
  1188.  
  1189.                 // Scan Other Rows
  1190.                 lTop = PUSH_V_GRID;
  1191.                 if (lpGrigliaStruct->wFixedRows)
  1192.                     lTop = (lpGrigliaStruct->lpHorBars  +
  1193.                              lpGrigliaStruct->wFixedRows - 1)->lPos;
  1194.  
  1195.                 // Scan Other Columns
  1196.                 for (m = (lpGrigliaStruct->wFixedRows +
  1197.                           lpGrigliaStruct->nVScrollPos);
  1198.                            m < (SHORT)lpGrigliaStruct->wRows; ++m) {
  1199.  
  1200.                     if ((lVScroll =
  1201.                          Griglia_VertPos (m, lpGrigliaStruct)) !=
  1202.                           INVALID_POS) {
  1203.                         lBottom = PUSH_V_GRID + lVScroll -
  1204.                                     lpGrigliaStruct->yChar /
  1205.                                     (2 * INTERCOLUMN_FACTOR);
  1206.  
  1207.                         if (lBottom > (LONG)rStatic.bottom)
  1208.                             return;
  1209.                         else if (
  1210.                                    (lTop    <= pPoint.y) &&
  1211.                                    (lBottom >= pPoint.y)
  1212.                                   ) {
  1213.  
  1214.                             wRow = m;
  1215.  
  1216.                             if (
  1217.                                 (lpGrigliaStruct->wSelEndRow != wRow) ||
  1218.                                 (lpGrigliaStruct->wSelEndCol != wCol)
  1219.                                ) {
  1220.                                 // Set Selection to Cursor                            // Remove Selection
  1221.                                 PaintBlock (lpGrigliaStruct);
  1222.                                 lpGrigliaStruct->wSelEndRow = wRow;
  1223.                                 lpGrigliaStruct->wSelEndCol = wCol;
  1224.                                 PaintBlock (lpGrigliaStruct);
  1225.                             }
  1226.                             return;
  1227.                         }
  1228.                     }
  1229.                 }
  1230.             }
  1231.         }
  1232.     }
  1233. }   
  1234.  
  1235. //---------------------------------------------------------------------------
  1236. // LButtonUp
  1237. //---------------------------------------------------------------------------
  1238. void LButtonUp (PGRIGLIA lpGrigliaStruct,
  1239.                 POINT    pPoint) {
  1240.  
  1241.     UINT n;
  1242.     static RECT rRect;
  1243.  
  1244.     if (!IsRectEmpty ((LPRECT)&rButton)) {
  1245.  
  1246.         HDC hDC;
  1247.  
  1248.         hDC = GetDC (lpGrigliaStruct->hWndStatic);
  1249.         PaintButtonUp (hDC,
  1250.                        rButton.left,
  1251.                        rButton.top,
  1252.                        rButton.right,
  1253.                        rButton.bottom);
  1254.         ReleaseDC (lpGrigliaStruct->hWndStatic, hDC);
  1255.         SetRectEmpty ((LPRECT)&rButton);
  1256.  
  1257.     } else {
  1258.         // TEMPORARILY
  1259.         return;
  1260.             
  1261.         if (
  1262.             (pPoint.x < PUSH_H_GRID) &&
  1263.             (pPoint.y < PUSH_V_GRID)
  1264.            ) {
  1265.             HDC hDC;
  1266.         
  1267.             hDC = GetDC (lpGrigliaStruct->hWndStatic);
  1268.             PaintButtonUp (hDC,
  1269.                            1,
  1270.                            1,
  1271.                            PUSH_H_GRID - 1,
  1272.                            PUSH_V_GRID - 1);
  1273.             ReleaseDC (lpGrigliaStruct->hWndStatic, hDC);
  1274.         } else if (pPoint.x < PUSH_H_GRID) {
  1275.         
  1276.             // Scan Rows
  1277.             for (n = (lpGrigliaStruct->wFixedRows +
  1278.                       lpGrigliaStruct->nVScrollPos);
  1279.                  n < lpGrigliaStruct->wRows;
  1280.                  ++n) {
  1281.         
  1282.                 if (
  1283.                     (CellTBRect (lpGrigliaStruct, n, (LPRECT)&rRect)) &&
  1284.                     (rRect.top    <= pPoint.x)                        &&
  1285.                     (rRect.bottom >= pPoint.x)
  1286.                    ) {
  1287.                     HDC hDC;    
  1288.             
  1289.                     hDC = GetDC (lpGrigliaStruct->hWndStatic);    
  1290.                     PaintButtonUp (hDC,
  1291.                                    1,
  1292.                                    rRect.top + 1,
  1293.                                    PUSH_H_GRID - 1,
  1294.                                    rRect.bottom);
  1295.                     ReleaseDC (lpGrigliaStruct->hWndStatic, hDC);    
  1296.                 }    
  1297.             }
  1298.         } else if (pPoint.y < PUSH_V_GRID) {
  1299.         
  1300.             // Scan Columns
  1301.             for (n = (lpGrigliaStruct->wFixedCols + 
  1302.                       lpGrigliaStruct->nHScrollPos);
  1303.                  n < lpGrigliaStruct->wCols; 
  1304.                  ++n) {
  1305.         
  1306.                 if (
  1307.                     (CellLRRect (lpGrigliaStruct, n, (LPRECT)&rRect)) &&
  1308.                     (rRect.left   <= pPoint.x)                        &&                                  
  1309.                     (rRect.right  >= pPoint.x) 
  1310.                    ) {
  1311.                     HDC hDC;    
  1312.             
  1313.                     hDC = GetDC (lpGrigliaStruct->hWndStatic);    
  1314.                     PaintButtonUp (hDC,    
  1315.                                    rRect.left +     
  1316.                                    lpGrigliaStruct->xChar / (2 * INTERCOLUMN_FACTOR),     
  1317.                                    1,     
  1318.                                    rRect.right + 1,     
  1319.                                    PUSH_V_GRID - 1);     
  1320.                     ReleaseDC (lpGrigliaStruct->hWndStatic, hDC);    
  1321.                 }    
  1322.             }
  1323.         }
  1324.     }    
  1325. }
  1326.                       
  1327.         
  1328.